{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器学习练习-决策树\n",
    "\n",
    "实验要求：1，请将本实验中两处代码不完整的地方补充完整：2，如果出现graphviz问题，请尝试解决；3，对照本章ppt和本实验代码，理解决策树原理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1．分类决策树模型是表示基于特征对实例进行分类的树形结构。决策树可以转换成一个**if-then**规则的集合，也可以看作是定义在特征空间划分上的类的条件概率分布。\n",
    "\n",
    "2．决策树学习旨在构建一个与训练数据拟合很好，并且复杂度小的决策树。因为从可能的决策树中直接选取最优决策树是NP完全问题。现实中采用启发式方法学习次优的决策树。\n",
    "\n",
    "决策树学习算法包括3部分：特征选择、树的生成和树的剪枝。常用的算法有ID3、\n",
    "C4.5和CART。\n",
    "\n",
    "3．特征选择的目的在于选取对训练数据能够分类的特征。特征选择的关键是其准则。常用的准则如下：\n",
    "\n",
    "（1）样本集合$D$对特征$A$的信息增益（ID3）\n",
    "\n",
    "\n",
    "$$g(D, A)=H(D)-H(D|A)$$\n",
    "\n",
    "$$H(D)=-\\sum_{k=1}^{K} \\frac{\\left|C_{k}\\right|}{|D|} \\log _{2} \\frac{\\left|C_{k}\\right|}{|D|}$$\n",
    "\n",
    "$$H(D | A)=\\sum_{i=1}^{n} \\frac{\\left|D_{i}\\right|}{|D|} H\\left(D_{i}\\right)$$\n",
    "\n",
    "其中，$H(D)$是数据集$D$的熵，$H(D_i)$是数据集$D_i$的熵，$H(D|A)$是数据集$D$对特征$A$的条件熵。\t$D_i$是$D$中特征$A$取第$i$个值的样本子集，$C_k$是$D$中属于第$k$类的样本子集。$n$是特征$A$取 值的个数，$K$是类的个数。\n",
    "\n",
    "（2）样本集合$D$对特征$A$的信息增益比（C4.5）\n",
    "\n",
    "\n",
    "$$g_{R}(D, A)=\\frac{g(D, A)}{H(D)}$$\n",
    "\n",
    "\n",
    "其中，$g(D,A)$是信息增益，$H(D)$是数据集$D$的熵。\n",
    "\n",
    "（3）样本集合$D$的基尼指数（CART）\n",
    "\n",
    "$$\\operatorname{Gini}(D)=1-\\sum_{k=1}^{K}\\left(\\frac{\\left|C_{k}\\right|}{|D|}\\right)^{2}$$\n",
    "\n",
    "特征$A$条件下集合$D$的基尼指数：\n",
    "\n",
    " $$\\operatorname{Gini}(D, A)=\\frac{\\left|D_{1}\\right|}{|D|} \\operatorname{Gini}\\left(D_{1}\\right)+\\frac{\\left|D_{2}\\right|}{|D|} \\operatorname{Gini}\\left(D_{2}\\right)$$\n",
    " \n",
    "4．决策树的生成。通常使用信息增益最大、信息增益比最大或基尼指数最小作为特征选择的准则。决策树的生成往往通过计算信息增益或其他指标，从根结点开始，递归地产生决策树。这相当于用信息增益或其他准则不断地选取局部最优的特征，或将训练集分割为能够基本正确分类的子集。\n",
    "\n",
    "5．决策树的剪枝。由于生成的决策树存在过拟合问题，需要对它进行剪枝，以简化学到的决策树。决策树的剪枝，往往从已生成的树上剪掉一些叶结点或叶结点以上的子树，并将其父结点或根结点作为新的叶结点，从而简化生成的决策树。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "from math import log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data():\n",
    "    datasets = [['青年', '否', '否', '一般', '否'],\n",
    "               ['青年', '否', '否', '好', '否'],\n",
    "               ['青年', '是', '否', '好', '是'],\n",
    "               ['青年', '是', '是', '一般', '是'],\n",
    "               ['青年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '好', '否'],\n",
    "               ['中年', '是', '是', '好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '好', '是'],\n",
    "               ['老年', '是', '否', '好', '是'],\n",
    "               ['老年', '是', '否', '非常好', '是'],\n",
    "               ['老年', '否', '否', '一般', '否'],\n",
    "               ]\n",
    "    labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']\n",
    "    # 返回数据集和每个维度的名称\n",
    "    return datasets, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.DataFrame  (datasets, columns=labels) #请将本行代码补充完整"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>年龄</th>\n",
       "      <th>有工作</th>\n",
       "      <th>有自己的房子</th>\n",
       "      <th>信贷情况</th>\n",
       "      <th>类别</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>一般</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>中年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    年龄 有工作 有自己的房子 信贷情况 类别\n",
       "0   青年   否      否   一般  否\n",
       "1   青年   否      否    好  否\n",
       "2   青年   是      否    好  是\n",
       "3   青年   是      是   一般  是\n",
       "4   青年   否      否   一般  否\n",
       "5   中年   否      否   一般  否\n",
       "6   中年   否      否    好  否\n",
       "7   中年   是      是    好  是\n",
       "8   中年   否      是  非常好  是\n",
       "9   中年   否      是  非常好  是\n",
       "10  老年   否      是  非常好  是\n",
       "11  老年   否      是    好  是\n",
       "12  老年   是      否    好  是\n",
       "13  老年   是      否  非常好  是\n",
       "14  老年   否      否   一般  否"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集的熵（信息熵）\n",
    "def calc_ent(datasets):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 统计数据集中每个类别的出现次数\n",
    "    label_count = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本的标签\n",
    "        label = datasets[i][-1]\n",
    "        # 如果该类别不在label_count中，则添加到label_count中\n",
    "        if label not in label_count:\n",
    "            label_count[label] = 0\n",
    "        # 统计该类别的出现次数\n",
    "        label_count[label] += 1\n",
    "    # 计算熵\n",
    "    ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                for p in label_count.values()])\n",
    "    return ent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 条件熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集在指定特征上的条件熵\n",
    "def cond_ent(datasets, axis=0):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 使用字典feature_sets存储在指定特征上的不同取值对应的样本集合\n",
    "    feature_sets = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本在指定特征上的取值\n",
    "        feature = datasets[i][axis]\n",
    "        # 如果该取值不在feature_sets中，则添加到feature_sets中\n",
    "        if feature not in feature_sets:\n",
    "            feature_sets[feature] = []\n",
    "        # 将该样本添加到对应取值的样本集合中\n",
    "        feature_sets[feature].append(datasets[i])\n",
    "    # 计算条件熵\n",
    "    cond_ent = sum([(len(p) / data_length) * calc_ent(p)\n",
    "                    for p in feature_sets.values()])\n",
    "    return cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_ent(datasets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 信息增益"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算信息增益\n",
    "def info_gain(ent, cond_ent):\n",
    "    # 信息增益等于熵减去条件熵\n",
    "    return ent - cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用信息增益选择最佳特征作为根节点特征进行决策树的训练\n",
    "def info_gain_train(datasets):\n",
    "    # 计算特征的数量\n",
    "    count = len(datasets[0]) - 1\n",
    "    # 计算整个数据集的熵\n",
    "    ent = calc_ent(datasets)\n",
    "    # 存储每个特征的信息增益\n",
    "    best_feature = []\n",
    "    for c in range(count):\n",
    "        # 计算每个特征的条件熵\n",
    "        c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))\n",
    "        # 将特征及其对应的信息增益存入best_feature列表中\n",
    "        best_feature.append((c, c_info_gain))\n",
    "        # 输出每个特征的信息增益\n",
    "        print('特征({}) 的信息增益为： {:.3f}'.format(labels[c], c_info_gain))\n",
    "    # 找到信息增益最大的特征\n",
    "    best_ = max(best_feature, key=lambda x: x[-1])\n",
    "    # 返回信息增益最大的特征作为根节点特征\n",
    "    return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征(年龄) 的信息增益为： 0.083\n",
      "特征(有工作) 的信息增益为： 0.324\n",
      "特征(有自己的房子) 的信息增益为： 0.420\n",
      "特征(信贷情况) 的信息增益为： 0.363\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'特征(有自己的房子)的信息增益最大，选择为根节点特征'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info_gain_train(np.array(datasets))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "### 利用ID3算法生成决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义节点类 二叉树\n",
    "class Node:\n",
    "    def __init__(self, root=True, label=None, feature_name=None, feature=None):\n",
    "        self.root = root\n",
    "        self.label = label\n",
    "        self.feature_name = feature_name\n",
    "        self.feature = feature\n",
    "        self.tree = {}\n",
    "        self.result = {\n",
    "            'label:': self.label,\n",
    "            'feature': self.feature,\n",
    "            'tree': self.tree\n",
    "        }\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '{}'.format(self.result)\n",
    "\n",
    "    def add_node(self, val, node):\n",
    "        self.tree[val] = node\n",
    "\n",
    "    def predict(self, features):\n",
    "        if self.root is True:\n",
    "            return self.label\n",
    "        return self.tree[features[self.feature]].predict(features)\n",
    "\n",
    "\n",
    "class DTree:\n",
    "    def __init__(self, epsilon=0.1):\n",
    "        self.epsilon = epsilon\n",
    "        self._tree = {}\n",
    "\n",
    "    # 熵\n",
    "    @staticmethod\n",
    "    def calc_ent(datasets):\n",
    "        data_length = len(datasets)\n",
    "        label_count = {}\n",
    "        for i in range(data_length):\n",
    "            label = datasets[i][-1]\n",
    "            if label not in label_count:\n",
    "                label_count[label] = 0\n",
    "            label_count[label] += 1\n",
    "        ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                    for p in label_count.values()])\n",
    "        return ent\n",
    "\n",
    "    # 经验条件熵\n",
    "    def cond_ent(self, datasets, axis=0):\n",
    "        data_length = len(datasets)\n",
    "        feature_sets = {}\n",
    "        for i in range(data_length):\n",
    "            feature = datasets[i][axis]\n",
    "            if feature not in feature_sets:\n",
    "                feature_sets[feature] = []\n",
    "            feature_sets[feature].append(datasets[i])\n",
    "        cond_ent = sum([(len(p) / data_length) * self.calc_ent(p)\n",
    "                        for p in feature_sets.values()])\n",
    "        return cond_ent\n",
    "\n",
    "    # 信息增益\n",
    "    @staticmethod\n",
    "    def info_gain(ent, cond_ent):\n",
    "        return ent - cond_ent\n",
    "\n",
    "    def info_gain_train(self, datasets):\n",
    "        count = len(datasets[0]) - 1\n",
    "        ent = self.calc_ent(datasets)\n",
    "        best_feature = []\n",
    "        for c in range(count):\n",
    "            c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))\n",
    "            best_feature.append((c, c_info_gain))\n",
    "        # 比较大小\n",
    "        best_ = max(best_feature, key=lambda x: x[-1])\n",
    "        return best_\n",
    "\n",
    "    def train(self, train_data):\n",
    "        \"\"\"\n",
    "        input:数据集D(DataFrame格式)，特征集A，阈值eta\n",
    "        output:决策树T\n",
    "        \"\"\"\n",
    "        _, y_train, features = train_data.iloc[:, :\n",
    "                                               -1], train_data.iloc[:,\n",
    "                                                                    -1], train_data.columns[:\n",
    "                                                                                            -1]\n",
    "        # 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T\n",
    "        if len(y_train.value_counts()) == 1:\n",
    "            return Node(root=True, label=y_train.iloc[0])\n",
    "\n",
    "        # 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T\n",
    "        if len(features) == 0:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征\n",
    "        max_feature, max_info_gain = self.info_gain_train(np.array(train_data))\n",
    "        max_feature_name = features[max_feature]\n",
    "\n",
    "        # 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T\n",
    "        if max_info_gain < self.epsilon:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 5,构建Ag子集\n",
    "        node_tree = Node(\n",
    "            root=False, feature_name=max_feature_name, feature=max_feature)\n",
    "\n",
    "        feature_list = train_data[max_feature_name].value_counts().index\n",
    "        for f in feature_list:\n",
    "            sub_train_df = train_data.loc[train_data[max_feature_name] ==\n",
    "                                          f].drop([max_feature_name], axis=1)\n",
    "\n",
    "            # 6, 递归生成树\n",
    "            sub_tree = self.train(sub_train_df)\n",
    "            node_tree.add_node(f, sub_tree)\n",
    "\n",
    "        # pprint.pprint(node_tree.tree)\n",
    "        return node_tree\n",
    "\n",
    "    def fit(self, train_data):\n",
    "        self._tree = self.train(train_data)\n",
    "        return self._tree\n",
    "\n",
    "    def predict(self, X_test):\n",
    "        return self._tree.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()\n",
    "data_df = pd.DataFrame(datasets, columns=labels)\n",
    "dt = DTree()\n",
    "tree = dt.fit(data_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'否'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.predict(['老年', '否', '否', '一般'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用Iris数据集，我们可以构建如下树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data\n",
    "def create_data():\n",
    "    iris = load_iris() #请将本行代码补充完整       \n",
    "    df = pd.DataFrame(iris.data, columns=iris.feature_names)\n",
    "    df['label'] = iris.target\n",
    "    df.columns = [\n",
    "        'sepal length', 'sepal width', 'petal length', 'petal width', 'label'\n",
    "    ]\n",
    "    data = np.array(df.iloc[:100, [0, 1, -1]])\n",
    "    # print(data)\n",
    "    return data[:, :2], data[:, -1],iris.feature_names[0:2]\n",
    "\n",
    "\n",
    "X, y,feature_name= create_data()\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9666666666666667"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.tree import export_graphviz\n",
    "import graphviz\n",
    "from sklearn import tree\n",
    "\n",
    "clf = DecisionTreeClassifier()\n",
    "clf.fit(X_train, y_train,)\n",
    "\n",
    "clf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一旦经过训练，就可以用 plot_tree函数绘制树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5909090909090909, 0.9, 'x[0] <= 5.45\\ngini = 0.5\\nsamples = 70\\nvalue = [36, 34]'),\n",
       " Text(0.36363636363636365, 0.7, 'x[1] <= 2.85\\ngini = 0.202\\nsamples = 35\\nvalue = [31, 4]'),\n",
       " Text(0.4772727272727273, 0.8, 'True  '),\n",
       " Text(0.18181818181818182, 0.5, 'x[0] <= 4.7\\ngini = 0.375\\nsamples = 4\\nvalue = [1, 3]'),\n",
       " Text(0.09090909090909091, 0.3, 'gini = 0.0\\nsamples = 1\\nvalue = [1, 0]'),\n",
       " Text(0.2727272727272727, 0.3, 'gini = 0.0\\nsamples = 3\\nvalue = [0, 3]'),\n",
       " Text(0.5454545454545454, 0.5, 'x[0] <= 5.3\\ngini = 0.062\\nsamples = 31\\nvalue = [30, 1]'),\n",
       " Text(0.45454545454545453, 0.3, 'gini = 0.0\\nsamples = 27\\nvalue = [27, 0]'),\n",
       " Text(0.6363636363636364, 0.3, 'x[1] <= 3.2\\ngini = 0.375\\nsamples = 4\\nvalue = [3, 1]'),\n",
       " Text(0.5454545454545454, 0.1, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1]'),\n",
       " Text(0.7272727272727273, 0.1, 'gini = 0.0\\nsamples = 3\\nvalue = [3, 0]'),\n",
       " Text(0.8181818181818182, 0.7, 'x[1] <= 3.4\\ngini = 0.245\\nsamples = 35\\nvalue = [5, 30]'),\n",
       " Text(0.7045454545454546, 0.8, '  False'),\n",
       " Text(0.7272727272727273, 0.5, 'gini = 0.0\\nsamples = 30\\nvalue = [0, 30]'),\n",
       " Text(0.9090909090909091, 0.5, 'gini = 0.0\\nsamples = 5\\nvalue = [5, 0]')]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree.plot_tree(clf) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以导出树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_pic = export_graphviz(clf, out_file=\"mytree.pdf\")\n",
    "with open('mytree.pdf') as f:\n",
    "    dot_graph = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.2.1 (20241206.2353)\n",
       " -->\n",
       "<!-- Title: Tree Pages: 1 -->\n",
       "<svg width=\"566pt\" height=\"491pt\"\n",
       " viewBox=\"0.00 0.00 566.00 491.25\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 487.25)\">\n",
       "<title>Tree</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-487.25 562,-487.25 562,4 -4,4\"/>\n",
       "<!-- 0 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>0</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"389.5,-483.25 280.5,-483.25 280.5,-412.25 389.5,-412.25 389.5,-483.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-465.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.45</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-450.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.5</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-434.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 70</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-418.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [36, 34]</text>\n",
       "</g>\n",
       "<!-- 1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>1</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"325.75,-376.25 224.25,-376.25 224.25,-305.25 325.75,-305.25 325.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 2.85</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.202</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 35</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [31, 4]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>0&#45;&gt;1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M315.02,-411.79C310.37,-403.64 305.35,-394.86 300.49,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"303.64,-384.82 295.64,-377.87 297.57,-388.29 303.64,-384.82\"/>\n",
       "<text text-anchor=\"middle\" x=\"288.31\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">True</text>\n",
       "</g>\n",
       "<!-- 10 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>10</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"445.75,-376.25 344.25,-376.25 344.25,-305.25 445.75,-305.25 445.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.4</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.245</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 35</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [5, 30]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;10 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>0&#45;&gt;10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M354.98,-411.79C359.63,-403.64 364.65,-394.86 369.51,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"372.43,-388.29 374.36,-377.87 366.36,-384.82 372.43,-388.29\"/>\n",
       "<text text-anchor=\"middle\" x=\"381.69\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">False</text>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>2</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"206,-269.25 112,-269.25 112,-198.25 206,-198.25 206,-269.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-251.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 4.7</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-236.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.375</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-220.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 4</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-204.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [1, 3]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>1&#45;&gt;2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M236.37,-304.79C226.59,-295.93 215.98,-286.32 205.84,-277.14\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"208.34,-274.69 198.58,-270.58 203.64,-279.88 208.34,-274.69\"/>\n",
       "</g>\n",
       "<!-- 5 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>5</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"325.75,-269.25 224.25,-269.25 224.25,-198.25 325.75,-198.25 325.75,-269.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-251.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.3</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-236.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.062</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-220.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 31</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-204.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [30, 1]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>1&#45;&gt;5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M275,-304.79C275,-297.17 275,-289 275,-281.02\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"278.5,-281.07 275,-271.07 271.5,-281.07 278.5,-281.07\"/>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>3</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"94,-154.38 0,-154.38 0,-99.12 94,-99.12 94,-154.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-137.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-121.33\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 1</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-105.58\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [1, 0]</text>\n",
       "</g>\n",
       "<!-- 2&#45;&gt;3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>2&#45;&gt;3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M121.71,-197.79C109.5,-186.35 95.96,-173.65 83.8,-162.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"86.42,-159.91 76.73,-155.63 81.64,-165.02 86.42,-159.91\"/>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>4</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"206,-154.38 112,-154.38 112,-99.12 206,-99.12 206,-154.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-137.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-121.33\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 3</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-105.58\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 3]</text>\n",
       "</g>\n",
       "<!-- 2&#45;&gt;4 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>2&#45;&gt;4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M159,-197.79C159,-187.56 159,-176.32 159,-165.91\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"162.5,-166.1 159,-156.1 155.5,-166.1 162.5,-166.1\"/>\n",
       "</g>\n",
       "<!-- 6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>6</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"325.75,-154.38 224.25,-154.38 224.25,-99.12 325.75,-99.12 325.75,-154.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-137.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-121.33\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 27</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-105.58\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [27, 0]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;6 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>5&#45;&gt;6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M275,-197.79C275,-187.56 275,-176.32 275,-165.91\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"278.5,-166.1 275,-156.1 271.5,-166.1 278.5,-166.1\"/>\n",
       "</g>\n",
       "<!-- 7 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>7</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"438,-162.25 344,-162.25 344,-91.25 438,-91.25 438,-162.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"391\" y=\"-144.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.2</text>\n",
       "<text text-anchor=\"middle\" x=\"391\" y=\"-129.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.375</text>\n",
       "<text text-anchor=\"middle\" x=\"391\" y=\"-113.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 4</text>\n",
       "<text text-anchor=\"middle\" x=\"391\" y=\"-97.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [3, 1]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;7 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>5&#45;&gt;7</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M313.63,-197.79C323.41,-188.93 334.02,-179.32 344.16,-170.14\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"346.36,-172.88 351.42,-163.58 341.66,-167.69 346.36,-172.88\"/>\n",
       "</g>\n",
       "<!-- 8 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"382,-55.25 288,-55.25 288,0 382,0 382,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 1</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 1]</text>\n",
       "</g>\n",
       "<!-- 7&#45;&gt;8 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>7&#45;&gt;8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M370.94,-90.96C366.17,-82.68 361.06,-73.81 356.23,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"359.31,-63.78 351.28,-56.87 353.25,-67.28 359.31,-63.78\"/>\n",
       "</g>\n",
       "<!-- 9 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>9</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"494,-55.25 400,-55.25 400,0 494,0 494,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"447\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"447\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 3</text>\n",
       "<text text-anchor=\"middle\" x=\"447\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [3, 0]</text>\n",
       "</g>\n",
       "<!-- 7&#45;&gt;9 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>7&#45;&gt;9</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M411.06,-90.96C415.83,-82.68 420.94,-73.81 425.77,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"428.75,-67.28 430.72,-56.87 422.69,-63.78 428.75,-67.28\"/>\n",
       "</g>\n",
       "<!-- 11 -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>11</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"445.75,-261.38 344.25,-261.38 344.25,-206.12 445.75,-206.12 445.75,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 30</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 30]</text>\n",
       "</g>\n",
       "<!-- 10&#45;&gt;11 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>10&#45;&gt;11</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M395,-304.79C395,-294.56 395,-283.32 395,-272.91\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"398.5,-273.1 395,-263.1 391.5,-273.1 398.5,-273.1\"/>\n",
       "</g>\n",
       "<!-- 12 -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>12</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"558,-261.38 464,-261.38 464,-206.12 558,-206.12 558,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"511\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"511\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 5</text>\n",
       "<text text-anchor=\"middle\" x=\"511\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [5, 0]</text>\n",
       "</g>\n",
       "<!-- 10&#45;&gt;12 -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>10&#45;&gt;12</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M433.63,-304.79C446.26,-293.35 460.29,-280.65 472.89,-269.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"475.16,-271.91 480.23,-262.61 470.46,-266.72 475.16,-271.91\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.sources.Source at 0x1fdfe61e7b0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graphviz.Source(dot_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a random dataset\n",
    "rng = np.random.RandomState(1)\n",
    "X = np.sort(5 * rng.rand(80, 1), axis=0)\n",
    "y = np.sin(X).ravel()\n",
    "y[::5] += 3 * (0.5 - rng.rand(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fit regression model\n",
    "regr_1 = DecisionTreeRegressor(max_depth=2)\n",
    "regr_2 = DecisionTreeRegressor(max_depth=5)\n",
    "regr_1.fit(X, y)\n",
    "regr_2.fit(X, y)\n",
    "\n",
    "# Predict\n",
    "X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]\n",
    "y_1 = regr_1.predict(X_test)\n",
    "y_2 = regr_2.predict(X_test)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure()\n",
    "plt.scatter(X, y, s=20, edgecolor=\"black\", c=\"darkorange\", label=\"data\")\n",
    "plt.plot(X_test, y_1, color=\"cornflowerblue\", label=\"max_depth=2\", linewidth=2)\n",
    "plt.plot(X_test, y_2, color=\"yellowgreen\", label=\"max_depth=5\", linewidth=2)\n",
    "plt.xlabel(\"data\")\n",
    "plt.ylabel(\"target\")\n",
    "plt.title(\"Decision Tree Regression\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn 的决策树参数"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "DecisionTreeClassifier(criterion=\"gini\",\n",
    "                 splitter=\"best\",\n",
    "                 max_depth=None,\n",
    "                 min_samples_split=2,\n",
    "                 min_samples_leaf=1,\n",
    "                 min_weight_fraction_leaf=0.,\n",
    "                 max_features=None,\n",
    "                 random_state=None,\n",
    "                 max_leaf_nodes=None,\n",
    "                 min_impurity_decrease=0.,\n",
    "                 min_impurity_split=None,\n",
    "                 class_weight=None,\n",
    "                 presort=False)\n",
    "\n",
    "参数含义：\n",
    "1.criterion:string, optional (default=\"gini\")\n",
    "            (1).criterion='gini',分裂节点时评价准则是Gini指数。\n",
    "            (2).criterion='entropy',分裂节点时的评价指标是信息增益。\n",
    "2.max_depth:int or None, optional (default=None)。指定树的最大深度。\n",
    "            如果为None，表示树的深度不限。直到所有的叶子节点都是纯净的，即叶子节点\n",
    "            中所有的样本点都属于同一个类别。或者每个叶子节点包含的样本数小于min_samples_split。\n",
    "3.splitter:string, optional (default=\"best\")。指定分裂节点时的策略。\n",
    "           (1).splitter='best',表示选择最优的分裂策略。\n",
    "           (2).splitter='random',表示选择最好的随机切分策略。\n",
    "4.min_samples_split:int, float, optional (default=2)。表示分裂一个内部节点需要的做少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每次分裂最少样本数为ceil(min_samples_split * n_samples)\n",
    "5.min_samples_leaf: int, float, optional (default=1)。指定每个叶子节点需要的最少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每个叶子节点最少样本数为ceil(min_samples_leaf * n_samples)\n",
    "6.min_weight_fraction_leaf:float, optional (default=0.)\n",
    "           指定叶子节点中样本的最小权重。\n",
    "7.max_features:int, float, string or None, optional (default=None).\n",
    "           搜寻最佳划分的时候考虑的特征数量。\n",
    "           (1).如果为整数，每次分裂只考虑max_features个特征。\n",
    "           (2).如果为浮点数(0到1之间)，每次切分只考虑int(max_features * n_features)个特征。\n",
    "           (3).如果为'auto'或者'sqrt',则每次切分只考虑sqrt(n_features)个特征\n",
    "           (4).如果为'log2',则每次切分只考虑log2(n_features)个特征。\n",
    "           (5).如果为None,则每次切分考虑n_features个特征。\n",
    "           (6).如果已经考虑了max_features个特征，但还是没有找到一个有效的切分，那么还会继续寻找\n",
    "           下一个特征，直到找到一个有效的切分为止。\n",
    "8.random_state:int, RandomState instance or None, optional (default=None)\n",
    "           (1).如果为整数，则它指定了随机数生成器的种子。\n",
    "           (2).如果为RandomState实例，则指定了随机数生成器。\n",
    "           (3).如果为None，则使用默认的随机数生成器。\n",
    "9.max_leaf_nodes: int or None, optional (default=None)。指定了叶子节点的最大数量。\n",
    "           (1).如果为None,叶子节点数量不限。\n",
    "           (2).如果为整数，则max_depth被忽略。\n",
    "10.min_impurity_decrease:float, optional (default=0.)\n",
    "         如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease，则分裂该节点。\n",
    "         加权不纯度的减少量计算公式为：\n",
    "         min_impurity_decrease=N_t / N * (impurity - N_t_R / N_t * right_impurity\n",
    "                            - N_t_L / N_t * left_impurity)\n",
    "         其中N是样本的总数，N_t是当前节点的样本数，N_t_L是分裂后左子节点的样本数，\n",
    "         N_t_R是分裂后右子节点的样本数。impurity指当前节点的基尼指数，right_impurity指\n",
    "         分裂后右子节点的基尼指数。left_impurity指分裂后左子节点的基尼指数。\n",
    "11.min_impurity_split:float\n",
    "         树生长过程中早停止的阈值。如果当前节点的不纯度高于阈值，节点将分裂，否则它是叶子节点。\n",
    "         这个参数已经被弃用。用min_impurity_decrease代替了min_impurity_split。\n",
    "12.class_weight:dict, list of dicts, \"balanced\" or None, default=None\n",
    "         类别权重的形式为{class_label: weight}\n",
    "         (1).如果没有给出每个类别的权重，则每个类别的权重都为1。\n",
    "         (2).如果class_weight='balanced'，则分类的权重与样本中每个类别出现的频率成反比。\n",
    "         计算公式为：n_samples / (n_classes * np.bincount(y))\n",
    "         (3).如果sample_weight提供了样本权重(由fit方法提供)，则这些权重都会乘以sample_weight。\n",
    "13.presort:bool, optional (default=False)\n",
    "        指定是否需要提前排序数据从而加速训练中寻找最优切分的过程。设置为True时，对于大数据集\n",
    "        会减慢总体的训练过程；但是对于一个小数据集或者设定了最大深度的情况下，会加速训练过程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树调参"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入库\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4) (150,)\n"
     ]
    }
   ],
   "source": [
    "# 导入数据集\n",
    "X = datasets.load_iris()  # 以全部字典形式返回,有data,target,target_names三个键\n",
    "data = X.data\n",
    "target = X.target\n",
    "name = X.target_names\n",
    "x, y = datasets.load_iris(return_X_y=True)  # 能一次性取前2个\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据分为训练集和测试集\n",
    "x_train, x_test, y_train, y_test = train_test_split(x,\n",
    "                                                    y,\n",
    "                                                    test_size=0.2,\n",
    "                                                    random_state=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最优分类器: {'criterion': 'gini', 'max_depth': 50, 'min_impurity_decrease': 0.1, 'min_samples_leaf': 5} 最优分数: 0.9416666666666665\n"
     ]
    }
   ],
   "source": [
    "# 用GridSearchCV寻找最优参数（字典）\n",
    "param = {\n",
    "    'criterion': ['gini'],\n",
    "    'max_depth': [30, 50, 60, 100],\n",
    "    'min_samples_leaf': [2, 3, 5, 10],\n",
    "    'min_impurity_decrease': [0.1, 0.2, 0.5]\n",
    "}\n",
    "grid = GridSearchCV(DecisionTreeClassifier(), param_grid=param, cv=6)\n",
    "grid.fit(x_train, y_train)\n",
    "print('最优分类器:', grid.best_params_, '最优分数:', grid.best_score_)  # 得到最优的参数和分值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参考\n",
    "\n",
    "- https://github.com/fengdu78/lihang-code\n",
    "\n",
    "- 李航. 统计学习方法[M]. 北京: 清华大学出版社,2019.\n",
    "\n",
    "- https://scikit-learn.org"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
